// 引入 react 依赖
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { DeviceEventEmitter, Platform, Alert, Dimensions } from 'react-native';
import AsyncStorage from '@react-native-community/async-storage'
import Storage from 'react-native-storage';

// 引入第三方依赖
// import * as WeChat from 'react-native-wechat';
import { Actions } from 'react-native-router-flux';
import RNFetchBlob from 'rn-fetch-blob'
import { Toast, Portal } from '@ant-design/react-native';
import axios from 'axios';
import request from '../api/request';
import AliyunPush from 'react-native-aliyun-push';


// antd 按需加载

// 引入 处理数据 所需文件
import { } from '../module/module.js';

// redux
import store from '../store/store';
import * as ActionTypes from '../constants/constants.js';

// 接口前缀
export const pathHead = 'http://e-trader.io';
export const path = `${pathHead}/v1/app`;


export const ScreenWidth = Dimensions.get('window').width;
export const ScreenHeight = Dimensions.get('window').height;
export const ScreenScale = Dimensions.get('window').scale;

export const size = (number, type) => {
  if (type == 'interval') {
    return ScreenWidth - number - number;
  }
  return (number / 750) * ScreenWidth;
};

// 初始化 storage
export const storage = new Storage({
  // 最大容量，默认值1000条数据循环存储
  size: 9999999999999,

  // 存储引擎：对于RN使用AsyncStorage，对于web使用window.localStorage
  // 如果不指定则数据只会保存在内存中，重启后即丢失
  storageBackend: AsyncStorage,

  // 数据过期时间，默认一整天（1000 * 3600 * 24 毫秒），设为null则永不过期
  defaultExpires: null,

  // 读写时在内存中缓存数据。默认启用。
  enableCache: true,

  // 如果storage中没有相应数据，或数据已过期，
  // 则会调用相应的sync方法，无缝返回最新数据。
  // sync方法的具体说明会在后文提到
  // 你可以在构造函数这里就写好sync的方法
  // 或是在任何时候，直接对storage.sync进行赋值修改
  // 或是写到另一个文件里，这里require引入
  // sync: {
  //     // sync方法的名字必须和所存数据的key完全相同
  //     // 方法接受的参数为一整个object，所有参数从object中解构取出
  //     // 这里可以使用promise。或是使用普通回调函数，但需要调用resolve或reject。
  //     user(params) {
  //         let { user_no, resolve, reject, syncParams: { extraFetchOptions, someFlag } } = params;
  //         getUserInfo(user_no, (res) => {
  //             // 成功则调用resolve
  //             resolve && resolve(res);
  //         }, () => {
  //             // 失败则调用reject
  //             reject && reject(new Error('data parse error'));
  //         })
  //     }
  // }

});

// 清除图片缓存
export function clearCache() {
}

// 往 storage 中保存指定信息
export function saveData(key, data) {
  // console.log('saveData ———— ', key, data)
  storage.save({
    key, // 注意:请不要在key中使用_下划线符号!
    data,
    // 如果不指定过期时间，则会使用defaultExpires参数
    // 如果设为null，则永不过期
    expires: null,
  }).then(res => {
    // console.log(res)
  });
}

// 从 storage 中获取指定信息
export function loadData(key, callback) {
  return new Promise((resolve, reject) => {
    // 请求账户信息
    storage.load({
      key,
      // autoSync(默认为true)意味着在没有找到数据或数据过期时自动调用相应的sync方法
      autoSync: true,
      // syncInBackground(默认为true)意味着如果数据过期，
      // 在调用sync方法的同时先返回已经过期的数据。
      // 设置为false的话，则等待sync方法提供的最新数据(当然会需要更多时间)。
      syncInBackground: true,
    }).then((res) => {
      // console.log('loadData ———— end', key, res)
      resolve(res)
    }).catch((err) => {
      // console.log('loadData ———— error', key, err)
      reject(null)
    });
  }).catch(error => {
    console.log(error)
  })
}

// 从 storage 中删除指定信息
export function removeData(key, callback) {
  // 请求账户信息
  storage.remove({
    key,
  });
}

export const getHeaderHeight = () => {
  const height = getStatusHeight() + 44;
  return height;
};

export const requestMessage = (res, loading, message) => {
  Toast.remove(loading);
  return new Promise((resolve, reject) => {
    if (res.error) {
      if (message) {
        Toast.fail(message.error, 1, null, false);
      }
      reject(res);
    } else if (res.data) {
      if (res.data.code == 200 || res.data.code == 1000) {
        if (message) {
          Toast.success(message.success, 1, null, false);
        }
        resolve(res.data);
      } else {
        if (message) {
          Toast.fail(message.error, 1, null, false);
        }
        reject(res.data);
      }
    } else {
      if (message) {
        Toast.fail(message.error, 1, null, false);
      }
      reject(res.data);
    }
  });
};


export const requstPromise = (res, callback) => {
  return new Promise((resolve, reject) => {
    console.log(res.data)
    if (res.data && res.data.code && res.data.code == 200) {
      callback ? callback() : null
      resolve(res.data);
    } else {
      console.log(res.data)
      // Toast.info(res.message)
      reject(res.data);
    }
  })
}

export const initApp = async () => {
  console.log(store)
  const { dispatch } = store
  let token = await loadData('token')
  // let loginInfo = await loadData('loginInfo')
  let userInfo = await loadData('userInfo')
  // if (loginInfo) {
  //   dispatch({
  //     type: ActionTypes.setLoginInfo,
  //     data: loginInfo,
  //   })
  // }
  console.log(userInfo)
  if (userInfo && userInfo.id) {

    dispatch({
      type: ActionTypes.setUserInfo,
      data: userInfo,
    })
    AliyunPush.bindAccount(userInfo.id.toString())
      .then((data) => {
        console.log("bindAccount success");
        console.log(JSON.stringify(data));
        // Actions.home({ type: "reset" })
      })
      .catch((error) => {
        console.log("bindAccount error");
        console.log(JSON.stringify(error));
      });
    Actions.reset('lightbox')
  } else {
    Actions.reset('login')
  }
}

export const loadingApp = async (loading) => {
  await initUser()
  await deliveryAddressDefault()
  Portal.remove(loading)
  // console.log('loadingApp')
  Actions.mall()
}

export const initUser = () => {
  const { dispatch } = store
  return new Promise(async (resolve, reject) => {
    let user = await my()
    let coin = await myCoin()
    let cv = await myCv()
    let integral = await myIntegral()
    resolve()
  })
}

export const borderBootom = (option) => {
  return {
    borderBottomWidth: option && option.width ? option.width : 1,
    borderColor: option && option.color ? option.color : borderColor,
  }
}

export const borderTop = (option) => {
  return {
    borderTopWidth: option && option.width ? option.width : 1,
    borderColor: option && option.color ? option.color : borderColor,
  }
}

export const borderLeft = (option) => {
  return {
    borderLeftWidth: option && option.width ? option.width : 1,
    borderColor: option && option.color ? option.color : borderColor,
  }
}

export const borderRight = (option) => {
  return {
    borderRightWidth: option && option.width ? option.width : 1,
    borderColor: option && option.color ? option.color : borderColor,
  }
}


export const validation = {
  phone(value) {
    var reg = /^\d{9,11}$/
    return reg.test(value)
  },
  email(value) {
    var reg = /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/
    return reg.test(value)
  },
}

export function FileUpload(id, image) {
  return new Promise((resolve, reject) => {
    let PATH = Platform.OS == 'ios' ? image.path.replace('file:///', '') : image.path;
    RNFetchBlob.fetch('POST', path + '/upload/' + id, {
      // 上传图片要设置Header
      'Content-Type': 'multipart/form-data',
    }, [{
      name: 'file',
      filename: 'file',
      data: RNFetchBlob.wrap(PATH),
      path: RNFetchBlob.wrap(PATH)
    }])
      .uploadProgress((written, total) => {
        // 本地查找进度
        console.log(written, total)
      })
      .progress((received, total) => {
        let perent = received / total;
        // 上传进度打印
        console.log(perent);
      })
      .then((response) => {
        console.log(response)
        return response.json()
      })
      .then((response) => {
        // 上传信息返回
        console.log(response);
        resolve(response)
      })
      .catch((error) => {
        // 错误信息
        console.log(error);
        reject(error)
      });
  })
}
